package org.example.blogserver.blog.service.Impl;

import com.github.pagehelper.PageHelper;

import com.github.pagehelper.PageInfo;
import org.example.blogpojo.blog.domain.ArticleType;
import org.example.blogpojo.blog.domain.Classity;
import org.example.blogpojo.blog.query.ArticleTypeQuery;
import org.example.blogpojo.blog.vo.ArticleTypeVo;
import org.example.blogserver.blog.mapper.ArticleTypeMapper;
import org.example.blogserver.blog.service.ArticleTypeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.*;

@Service
public class ArticleTypeServiceImpl implements ArticleTypeService {
    @Autowired
    private ArticleTypeMapper articleTypeMapper;

    @Autowired
    private RedisTemplate<Object, Object> redisTemplate;
    @Override
    public List<ArticleType> getAllArticleType() {
        return articleTypeMapper.getAllArticleType();
    }

    @Override
    public ArticleType getArticleTypeById(Long id) {
        return articleTypeMapper.getArticleTypeById(id);
    }

    @Override
    public PageInfo<ArticleType> queryPage(ArticleTypeQuery articleTypeQuery) {
        System.out.println(articleTypeQuery.toString());
        PageHelper.startPage(articleTypeQuery.getPageNum(), articleTypeQuery.getPageSize());
        List<ArticleType> articleTypes = articleTypeMapper.queryPage(articleTypeQuery);
        return new PageInfo<ArticleType>(articleTypes);
    }

    @Override
    @CacheEvict(cacheNames = "articleType", key = "'typeTree'")
    public void insertArticleType(ArticleType articleType) {
        articleTypeMapper.insertArticleType(articleType);
    }

    @Override
    @CacheEvict(cacheNames = "articleType", key = "'typeTree'")
    public void updateArticleType(ArticleType articleType) {
        articleType.setUpdateTime(new Date());
        articleTypeMapper.updateArticleType(articleType);
    }

    @Override
    @CacheEvict(cacheNames = "articleType", key = "'typeTree'")
    public void deleteArticleType(Long id) {
        articleTypeMapper.deleteArticleType(id);
    }

    @Override
    @CacheEvict(cacheNames = "articleType", key = "'typeTree'")
    public void deleteArticleTypeByIds(Long[] ids) {
        articleTypeMapper.deleteArticleTypeByIds(ids);
    }

    @Override
    @Cacheable(cacheNames = "articleType", key = "'typeTree'")
    public  List<ArticleType> getTypeTree(Long id) {
        List<ArticleType> typeTree = new ArrayList<>();//类型树,本质是一个集合
        //找到所有的类型,判断每一个类型的parentId是否是null
        //如果是null,说明这个类型是一级类型,就添加到类型树(集合)
        //如果不是null,说明这个类型是子级类型,找到子类型的一级类型,拿到一级类型的子类型集合,把这个子级类型添加到这个子类型集合
        List<ArticleType> allList = articleTypeMapper.getAllArticleType();
        Map<Long,ArticleType> map = new HashMap<>();//缓存好做对比
        //List<ArticleType> map = new ArrayList<>();
        //for (ArticleType articleType : allList) {
        //    map.put(articleType.getId(),articleType);
        //}
        //for (ArticleType articleType : allList) {
        //    if(id.equals(articleType.getId())){
        //        continue;
        //    }
        //    Long parentId = (articleType.getParentId());
        //    if (parentId==null){
        //        typeTree.add(articleType);//所有一级,所有的爹
        //    }else {
        //        //根据id找到一个类型,映射map<id,articleType>缺啥补啥
        //        ArticleType parent = map.get(articleType.getId());//找到这个儿子对应的爹,
        //        parent.getChildren().add(articleType);//所有的一级,所有的爹装它的儿子们
        //    }
        //}
        allList.forEach(articleType->map.put(articleType.getId(),articleType));
        allList.forEach(articleType->{
            if(id.equals(articleType.getId())){
                return;
            }
            if(articleType.getParentId()==null){
                typeTree.add(articleType);
            }else {
                ArticleType parent = map.get(articleType.getParentId());
                parent.getChildren().add(articleType);
            }
        });
        return typeTree;
    }

    @Override
    public List<ArticleTypeVo> getArticleTypeVo() {
        return articleTypeMapper.getArticleTypeVo();
    }

    @Override
    public Map<Integer,Classity> getClassityList() {
        Map<Integer, Classity> map = new HashMap<>();
        List<Classity> allList = articleTypeMapper.getClassityList();
        // 遍历所有对象，按id分组
        for (Classity clazz : allList) {
            Integer id = clazz.getId();
            // 如果map中没有该id的对象，新建一个并放入map（作为分组的容器）
            if (!map.containsKey(id)) {
                Classity group = new Classity();
                group.setTid(clazz.getTid());
                group.setId(id);
                group.setArticleName(clazz.getArticleName()); // 保留第一个对象的基本信息
                group.setTypeName(clazz.getTypeName());
                map.put(id, group);
            }
            // 给map中该id对应的分组对象的clazz列表添加当前对象
            map.get(id).getClazz().add(clazz);
        }
        // 将map中的分组对象转换为列表返回
        return map;
    }

}
